Media processing applications sometimes incorporate third party components. For example, a principal application may perform a high-level media processing task (such as DVD authoring), and the high-level task may, in turn, rely on one or more third party components to perform basic operations encompassed by the task (such as compressing, packetizing, multiplexing, and so on). An application may adopt this implementation strategy for various reasons. For example, an application designer may wish to reduce the cost of the application by relying on existing third-party components. Or an application designer may wish to rely on third party components (rather than building such functionality into the application itself) for license-related reasons.
The task of selecting and configuring third party components may raise a number of challenges. First, an application may have complex requirements. The pool of available components may have equally complex capabilities. It is a difficult task to match the requirements of an application with the capabilities of the components. Second, it is a difficult task to ensure that the selected third party components work well together to achieve a desired end result. That is, one third party component may have a set of features (and configuration states) which conflict with the features (and configuration states) of one or more other third party components. Such conflicts can produce a configuration having an inconsistent state, which may cause the combination of components to perform in a suboptimal manner. Or such conflict may completely disable the combination of components. Third, it is difficult to modify third party components to provide enhancements and extensions to existing configurations, while still ensuring that these components consistently work with applications which may be unaware of such extensions.
The above challenges can be addressed in an ad hoc manner by a designing a custom configuration solution for each application. But this approach is problematic. For instance, to avoid configuration problems, this approach may require the application designer to have intimate familiarity with the media processing requirements, of the application, the capabilities of different components, and the manner in which different components interact. This approach may also require the designer to have expert knowledge of complex algorithms used by different multimedia compression storage formats. Further, this approach may also require the end-user to have advanced knowledge of media processing options in order to properly interact with the application, that is, by inputting configuration parameters into the user interface presentations provided by the application. Any misstep by the application designer or the end-user may produce an inconsistent state in the selected combination of components, possibly rendering the application non-functional. For example, as appreciated by the present inventors, the order in which configuration parameters are set is important; if the parameters are not set in an appropriate order, then the combination of components may be placed in an inconsistent state.
Moreover, the ad hoc approach is generally not extensible, meaning that it cannot be easily modified to suit variations in the application environment or the pool of available components. For instance, any modification to the configuration settings may require difficult analysis and significant design modification to ensure that the changes do not produce an inconsistent state. Again, this task may require expert knowledge in media processing arts.
According to another challenge, the application designer may attempt to design media processing functionality that supports a wide variety of media storage formats. An application designer may address this objective by creating a complex abstraction software layer that makes different formats appear “similar” for user interface and configuration purposes. But this is a difficult task that adds complexity and cost to the media processing functionality. Such a cumbersome abstraction layer may also provide poor extensibility with respect to future modifications made to the application, components, media formats, and so forth.
There is therefore an exemplary need for more satisfactory solutions for discovering, selecting, configuring, and controlling components used in media processing applications.